#ifndef _SERVER_HPP
#define _SERVER_HPP

#include "Reactor.hpp"
#include "Util.hpp"

static const int BUFFER_SIZE  = 1024;

/*
 *  -1: 发生错误
 *  0: 表示对端关闭连接
 *  > 0: 表示读取成功
*/ 
// 实际读取过程
int ReceiveCore(Event* event)
{
    while(true)
    {
        char buffer[BUFFER_SIZE];
        // 当作字符串处理？
        ssize_t s = recv(event->_sock, buffer, BUFFER_SIZE - 1, 0);
        // -1: 读取错误，1、可能已经读完 2、可能真的错误
        // 0: 对端关闭连接
        // > 0: 读取成功
        if(s == -1)
        {
            // 信号中断
            if(errno == EINTR) continue;
            if(errno == EAGAIN || errno == EWOULDBLOCK)
            {
                // 读取完成
                return 1;
            }

            return -1;
        }
        else if(s == 0)
        {
            // 对端关闭连接
            return 0;
        }
        else
        {
            buffer[s] = '\0';
            event->_in_buffer += buffer;
        }
    }

    return 0;
}

int Receive(Event* event)
{
    assert(event);
    fprintf(stdout, "开始处理读事件！\n");
    // 1、非阻塞IO
    int result = ReceiveCore(event);
    if(result <= 0)
    {
        // 差错处理
        event->_error(event);
    }
    
    // 2、处理粘包问题
    std::vector<std::string> tokens; 
    // 以Y作为分隔符
    std::string separate_op = "Y";
    SplitSegment(event, &tokens, separate_op);
    // 3、反序列化
    for(auto &segment: tokens)
    {
        std::string data1, data2, op;
        if(Deserialize(segment, &data1, &data2, &op))  
        {
            //std::cout << data1 << " " << op << " " << data2 << std::endl;
            // 反序列化成功 
            event->_out_buffer += data1;
            event->_out_buffer += op;
            event->_out_buffer += data2;
            event->_out_buffer += "=";
            // 4、业务处理
            event->_out_buffer += std::to_string(handler(data1, data2, op));   
            event->_out_buffer += "\n";
        }
        else
        {
            // 反序列化失败
            fprintf(stderr, "Deserializer error!\n");
        }
    }

    // 5、数据发送
    // 使用R指针调用使能读写进行设置
    if(!event->_out_buffer.empty())
    {
        std::cout << "成功调用使能读写！" << std::endl;
        event->_R->EnableAbility(event->_sock, true, true);
    }

    // 6、差错处理
    // 统一扔给Error
    return 0;
}

int SendCore(int sock, std::string& outbuffer)
{
    while(true)
    {
        // 本轮发送流量统计
        std::cout << outbuffer.size() << std::endl;
        int total = 0;
        int size = outbuffer.size();
        ssize_t s = send(sock, outbuffer.c_str(), size - total, 0); 
        if(s > 0)
        {
            total += s;
            if(size == total)
            {
                outbuffer.clear();
                return 1;
            }
        }
        else
        {
            if(errno == EINTR) continue;
            // 没有发完，但是不能再发了
            if(errno == EAGAIN || errno == EWOULDBLOCK)
            {
                return 0;
            }

            return -1;
        }
    }
}

int Send(Event* event)
{
    fprintf(stdout, "开始处理写事件！\n");
    int result = SendCore(event->_sock, event->_out_buffer);
    if(result == 1)
    {
        // 发送完成，使能设置
        event->_R->EnableAbility(event->_sock, true, false);
    }
    else if(result == 0)
    {
        // ToDo
    }
    else
    {
        // 差错处理
        event->_error(event);
    }

    return 0;
}

int Error(Event* event)
{
    fprintf(stdout, "开始处理错误事件！\n");
    // 删除Event
    event->_R->DeleteEvent(event);
    return 0;
}
#endif
